home *** CD-ROM | disk | FTP | other *** search
/ Champak 49 / Volume 49 - JOGO DISK .iso / Games / evilswitch.swf / scripts / DefineSprite_71 / frame_2 / DoAction.as
Encoding:
Text File  |  2007-09-27  |  16.2 KB  |  608 lines
  1. function GameGrid(aRange)
  2. {
  3.    this.init(aRange);
  4. }
  5. GameGrid.prototype.init = function(aRange)
  6. {
  7.    this.pData = new Array(64);
  8. };
  9. GameGrid.prototype.setRange = function(aRange)
  10. {
  11.    this.pColours = [1,2,3,4,5,6,7,8].slice(0,aRange);
  12.    this.fillGrid();
  13. };
  14. GameGrid.prototype.checkGrid = function()
  15. {
  16.    var _loc4_ = undefined;
  17.    var _loc3_ = undefined;
  18.    var _loc11_ = undefined;
  19.    var _loc12_ = undefined;
  20.    var _loc5_ = undefined;
  21.    var _loc9_ = undefined;
  22.    var _loc10_ = undefined;
  23.    var _loc6_ = new Array();
  24.    _loc4_ = _loc3_ = _loc11_ = _loc12_ = 0;
  25.    _loc5_ = 0;
  26.    while(_loc5_ < 64)
  27.    {
  28.       _loc9_ = _loc5_ >= 63 ? _loc5_ : _loc5_ * 8 % 63;
  29.       _loc10_ = this.getCellColour(_loc9_);
  30.       if(_loc10_ == _loc12_)
  31.       {
  32.          _loc3_ = _loc3_ + 1;
  33.       }
  34.       else
  35.       {
  36.          _loc12_ = _loc10_;
  37.          if(_loc3_ > 2)
  38.          {
  39.             var _loc7_ = 1;
  40.             while(_loc7_ <= _loc3_)
  41.             {
  42.                _loc6_.push(_loc9_ - _loc7_ * 8);
  43.                _loc7_ = _loc7_ + 1;
  44.             }
  45.             _parent.scores_mc.updateBonus();
  46.             _parent.scores_mc.updateScore(_loc3_);
  47.             _parent.pirate_mc.parrot_mc.playCombo();
  48.             _parent.timer_mc.addTimer(_loc3_);
  49.             updateBlockCount();
  50.          }
  51.          _loc3_ = 1;
  52.       }
  53.       if(_loc9_ > 55)
  54.       {
  55.          if(_loc3_ > 2)
  56.          {
  57.             _loc7_ = 0;
  58.             while(_loc7_ < _loc3_)
  59.             {
  60.                _loc6_.push(_loc9_ - _loc7_ * 8);
  61.                _loc7_ = _loc7_ + 1;
  62.             }
  63.             _parent.scores_mc.updateBonus();
  64.             _parent.scores_mc.updateScore(_loc3_);
  65.             _parent.pirate_mc.parrot_mc.playCombo();
  66.             _parent.timer_mc.addTimer(_loc3_);
  67.             updateBlockCount();
  68.          }
  69.          _loc3_ = 0;
  70.       }
  71.       _loc10_ = this.getCellColour(_loc5_);
  72.       if(_loc10_ == _loc11_)
  73.       {
  74.          _loc4_ = _loc4_ + 1;
  75.       }
  76.       else
  77.       {
  78.          _loc11_ = _loc10_;
  79.          if(_loc4_ > 2)
  80.          {
  81.             _loc7_ = 1;
  82.             while(_loc7_ <= _loc4_)
  83.             {
  84.                _loc6_.push(_loc5_ - _loc7_);
  85.                _loc7_ = _loc7_ + 1;
  86.             }
  87.             _parent.scores_mc.updateBonus();
  88.             _parent.scores_mc.updateScore(_loc4_);
  89.             _parent.pirate_mc.parrot_mc.playCombo();
  90.             _parent.timer_mc.addTimer(_loc4_);
  91.             updateBlockCount();
  92.          }
  93.          _loc4_ = 1;
  94.       }
  95.       if((_loc5_ + 1) % 8 == 0)
  96.       {
  97.          if(_loc4_ > 2)
  98.          {
  99.             _loc7_ = 0;
  100.             while(_loc7_ < _loc4_)
  101.             {
  102.                _loc6_.push(_loc5_ - _loc7_);
  103.                _loc7_ = _loc7_ + 1;
  104.             }
  105.             _parent.scores_mc.updateBonus();
  106.             _parent.scores_mc.updateScore(_loc4_);
  107.             _parent.pirate_mc.parrot_mc.playCombo();
  108.             _parent.timer_mc.addTimer(_loc4_);
  109.             updateBlockCount();
  110.          }
  111.          _loc4_ = 0;
  112.       }
  113.       _loc5_ = _loc5_ + 1;
  114.    }
  115.    if(_loc6_.length > 1)
  116.    {
  117.       var _loc13_ = _loc6_.length;
  118.       var _loc8_ = 0;
  119.       while(_loc8_ < _loc13_)
  120.       {
  121.          if(this.getCellColour(_loc6_[_loc8_]) == 0)
  122.          {
  123.             _loc6_.splice(_loc8_,1);
  124.             _loc13_ = _loc13_ - 1;
  125.             _loc8_ = _loc8_ - 1;
  126.          }
  127.          else
  128.          {
  129.             this.pData[_loc6_[_loc8_]] = 0;
  130.          }
  131.          _loc8_ = _loc8_ + 1;
  132.       }
  133.    }
  134.    return _loc6_;
  135. };
  136. GameGrid.prototype.removeBlocks = function()
  137. {
  138.    var _loc9_ = new Array([],[]);
  139.    var _loc10_ = this.pData.slice();
  140.    var _loc3_ = this.pColours.slice();
  141.    var _loc5_ = undefined;
  142.    var _loc2_ = undefined;
  143.    var _loc8_ = undefined;
  144.    var _loc7_ = 56;
  145.    while(_loc7_ < 64)
  146.    {
  147.       _loc5_ = 0;
  148.       _loc2_ = _loc7_ + 0;
  149.       _loc8_ = 0;
  150.       while(_loc2_ >= 0)
  151.       {
  152.          if(_loc10_[_loc2_] == 0)
  153.          {
  154.             if(_loc3_.length == 0)
  155.             {
  156.                _loc3_ = this.pColours.slice();
  157.             }
  158.             else
  159.             {
  160.                var _loc4_ = _loc3_[Math.round(Math.random() * (_loc3_.length - 1))];
  161.                _loc3_.splice(_loc3_.getItemIndex(_loc4_),1);
  162.             }
  163.             var _loc6_ = _loc7_ - 56 + _loc8_ * 8;
  164.             _loc9_[1].push(new Array(_loc2_,_loc6_,_loc4_));
  165.             this.pData[_loc6_] = _loc4_;
  166.             _loc8_ = _loc8_ + 1;
  167.             _loc5_ = _loc5_ + 1;
  168.          }
  169.          else if(_loc5_ > 0)
  170.          {
  171.             _loc9_[0].push(new Array(_loc2_,_loc5_));
  172.             this.pData[_loc2_ + _loc5_ * 8] = _loc10_[_loc2_];
  173.          }
  174.          _loc2_ -= 8;
  175.       }
  176.       _loc7_ = _loc7_ + 1;
  177.    }
  178.    return _loc9_;
  179. };
  180. GameGrid.prototype.checkBlocks = function(tCellNum)
  181. {
  182.    var _loc12_ = undefined;
  183.    var _loc11_ = undefined;
  184.    var _loc6_ = undefined;
  185.    var _loc14_ = undefined;
  186.    var _loc16_ = undefined;
  187.    var _loc15_ = undefined;
  188.    var _loc17_ = undefined;
  189.    var _loc3_ = undefined;
  190.    var _loc7_ = undefined;
  191.    var _loc8_ = undefined;
  192.    var _loc10_ = undefined;
  193.    var _loc9_ = undefined;
  194.    _loc12_ = new Array();
  195.    _loc11_ = new Array();
  196.    _loc6_ = this.getCellColour(tCellNum);
  197.    _loc14_ = Math.floor(tCellNum / 8);
  198.    _loc16_ = 7 - _loc14_;
  199.    _loc15_ = tCellNum - Math.floor(tCellNum / 8) * 8;
  200.    _loc17_ = 7 - _loc15_;
  201.    _loc7_ = 1;
  202.    while(_loc7_ <= _loc14_)
  203.    {
  204.       _loc3_ = tCellNum - _loc7_ * 8;
  205.       if(this.getCellColour(_loc3_) != _loc6_)
  206.       {
  207.          break;
  208.       }
  209.       _loc11_.push(_loc3_);
  210.       _loc7_ = _loc7_ + 1;
  211.    }
  212.    _loc8_ = 1;
  213.    while(_loc8_ <= _loc16_)
  214.    {
  215.       _loc3_ = tCellNum + _loc8_ * 8;
  216.       if(this.getCellColour(_loc3_) != _loc6_)
  217.       {
  218.          break;
  219.       }
  220.       _loc11_.push(_loc3_);
  221.       _loc8_ = _loc8_ + 1;
  222.    }
  223.    _loc10_ = 1;
  224.    while(_loc10_ <= _loc15_)
  225.    {
  226.       _loc3_ = tCellNum - _loc10_;
  227.       if(this.getCellColour(_loc3_) != _loc6_)
  228.       {
  229.          break;
  230.       }
  231.       _loc12_.push(_loc3_);
  232.       _loc10_ = _loc10_ + 1;
  233.    }
  234.    _loc9_ = 1;
  235.    while(_loc9_ <= _loc17_)
  236.    {
  237.       _loc3_ = tCellNum + _loc9_;
  238.       if(this.getCellColour(_loc3_) != _loc6_)
  239.       {
  240.          break;
  241.       }
  242.       _loc12_.push(_loc3_);
  243.       _loc9_ = _loc9_ + 1;
  244.    }
  245.    var _loc13_ = new Array();
  246.    _loc13_.push(tCellNum);
  247.    if(_loc12_.length >= 2)
  248.    {
  249.       _loc13_ = _loc13_.concat(_loc12_);
  250.       _parent.scores_mc.updateBonus();
  251.       _parent.scores_mc.updateScore(_loc12_.length + 1);
  252.       _parent.timer_mc.addTimer(_loc12_.length + 1);
  253.       updateBlockCount();
  254.    }
  255.    if(_loc11_.length >= 2)
  256.    {
  257.       _loc13_ = _loc13_.concat(_loc11_);
  258.       _parent.scores_mc.updateBonus();
  259.       _parent.scores_mc.updateScore(_loc11_.length + 1);
  260.       _parent.timer_mc.addTimer(_loc11_.length + 1);
  261.       updateBlockCount();
  262.    }
  263.    if(_loc13_.length > 1)
  264.    {
  265.       _parent.soul_mc.addTile(_loc6_);
  266.       var _loc18_ = _loc13_.length;
  267.       var _loc4_ = 0;
  268.       while(_loc4_ < _loc18_)
  269.       {
  270.          this.pData[_loc13_[_loc4_]] = 0;
  271.          _loc4_ = _loc4_ + 1;
  272.       }
  273.    }
  274.    return _loc13_;
  275. };
  276. GameGrid.prototype.swapBlocks = function(tCellID1, tCellID2)
  277. {
  278.    var _loc3_ = this.getCellColour(tCellID1);
  279.    var _loc2_ = this.getCellColour(tCellID2);
  280.    this.pData[tCellID1] = _loc2_;
  281.    this.pData[tCellID2] = _loc3_;
  282. };
  283. GameGrid.prototype.fillGrid = function()
  284. {
  285.    var _loc3_ = undefined;
  286.    var _loc5_ = undefined;
  287.    var _loc6_ = undefined;
  288.    var _loc4_ = undefined;
  289.    var _loc2_ = 0;
  290.    while(_loc2_ < 64)
  291.    {
  292.       _loc3_ = this.pColours.slice();
  293.       if(Math.round(_loc2_ % 8) > 1)
  294.       {
  295.          _loc6_ = this.getCellColour(_loc2_ - 1);
  296.          if(_loc6_ - this.getCellColour(_loc2_ - 2) == 0)
  297.          {
  298.             _loc4_ = _loc3_.getItemIndex(_loc6_);
  299.             _loc3_.splice(_loc4_,1);
  300.          }
  301.       }
  302.       if(Math.floor(_loc2_ / 8) > 1)
  303.       {
  304.          _loc5_ = this.getCellColour(_loc2_ - 8);
  305.          if(_loc5_ - this.getCellColour(_loc2_ - 16) == 0)
  306.          {
  307.             _loc4_ = _loc3_.getItemIndex(_loc5_);
  308.             _loc3_.splice(_loc4_,1);
  309.          }
  310.       }
  311.       this.pData[_loc2_] = _loc3_[Math.round(Math.random() * (_loc3_.length - 1))];
  312.       _loc2_ = _loc2_ + 1;
  313.    }
  314. };
  315. GameGrid.prototype.getCellColour = function(aNum)
  316. {
  317.    var _loc2_ = this.pData[aNum];
  318.    return _loc2_;
  319. };
  320. GameGrid.prototype.printGrid = function()
  321. {
  322.    var _loc3_ = "";
  323.    var _loc4_ = 0;
  324.    while(_loc4_ < 8)
  325.    {
  326.       _loc3_ = "";
  327.       var _loc2_ = 0;
  328.       while(_loc2_ < 8)
  329.       {
  330.          _loc3_ += this.getCellColour(_loc4_ * 8 + _loc2_);
  331.          _loc2_ = _loc2_ + 1;
  332.       }
  333.       _loc4_ = _loc4_ + 1;
  334.    }
  335. };
  336. this.init = function()
  337. {
  338.    this.pBlockCount = 0;
  339.    this.pLevelEnd = false;
  340.    this.pRange = 0;
  341.    this.pLevel = 1;
  342.    this.attachMovie("mc.selector","selector_mc",10000);
  343.    this.pGrid = new GameGrid(8);
  344.    this.pTileLocs = new Array(64);
  345.    this.pTileCheck = 0;
  346.    this.pSwappedTiles = new Array(2);
  347.    this.pClearedTiles = new Array();
  348.    this.setMask(this.tileMask_mc);
  349.    this.pComboSnd = new Sound(this);
  350.    this.pComboSnd.attachSound("snd.combo");
  351.    this.pErrorSnd = new Sound(this);
  352.    this.pErrorSnd.attachSound("snd.error");
  353.    this.pSwishSnd = new Sound(this);
  354.    this.pSwishSnd.attachSound("snd.swish");
  355.    this.pBellsSnd = new Sound(this);
  356.    this.pBellsSnd.attachSound("snd.bells");
  357.    var _loc3_ = undefined;
  358.    var _loc2_ = 0;
  359.    while(_loc2_ < 64)
  360.    {
  361.       _loc3_ = new Object();
  362.       _loc3_.pNum = _loc2_;
  363.       _loc3_.pPos = new Object();
  364.       _loc3_.pPos.x = -140 + 40 * (_loc2_ % 8);
  365.       _loc3_.pPos.y = -140 + 40 * Math.floor(_loc2_ / 8);
  366.       _loc3_.pColour = 1;
  367.       this.attachMovie("mc.tile","t" + _loc2_ + "_mc",_loc2_,_loc3_);
  368.       this.pTileLocs[_loc2_] = "t" + _loc2_ + "_mc";
  369.       _loc2_ = _loc2_ + 1;
  370.    }
  371. };
  372. this.printTileLocs = function()
  373. {
  374.    var _loc6_ = 0;
  375.    while(_loc6_ < 8)
  376.    {
  377.       var _loc4_ = "";
  378.       var _loc3_ = 0;
  379.       while(_loc3_ < 8)
  380.       {
  381.          var _loc5_ = _loc6_ * 8 + _loc3_;
  382.          var _loc2_ = this.pTileLocs[_loc5_];
  383.          _loc2_ = _loc2_.slice(1,-3);
  384.          _loc4_ = _loc4_ + _loc2_ + ", ";
  385.          _loc3_ = _loc3_ + 1;
  386.       }
  387.       _loc6_ = _loc6_ + 1;
  388.    }
  389. };
  390. this.updateBlockCount = function()
  391. {
  392.    this.pComboSnd.start();
  393.    this.pBlockCount = this.pBlockCount + 1;
  394.    if(this.pLevel < 5)
  395.    {
  396.       this.pLevelEnd = this.pBlockCount >= 20;
  397.    }
  398. };
  399. this.gameOver = function()
  400. {
  401.    this.pTileCheck = 0;
  402.    var _loc2_ = 0;
  403.    while(_loc2_ < 64)
  404.    {
  405.       this[this.pTileLocs[_loc2_]].destroyTile();
  406.       this.pTileCheck = this.pTileCheck + 1;
  407.       _loc2_ = _loc2_ + 1;
  408.    }
  409.    this.pBellsSnd.start();
  410. };
  411. this.tileDestroyDone = function()
  412. {
  413.    if(--this.pTileCheck == 0)
  414.    {
  415.       this._parent.gameover_mc.gotoAndPlay("end");
  416.    }
  417. };
  418. this.swapBlocks = function(aB1, aB2, aReturn)
  419. {
  420.    this.selector_mc.setActive(false);
  421.    var _loc5_ = -140 + 40 * (aB1 % 8);
  422.    var _loc7_ = -140 + 40 * Math.floor(aB1 / 8);
  423.    var _loc8_ = this.pTileLocs[aB1];
  424.    var _loc4_ = -140 + 40 * (aB2 % 8);
  425.    var _loc6_ = -140 + 40 * Math.floor(aB2 / 8);
  426.    var _loc9_ = this.pTileLocs[aB2];
  427.    if(_loc4_ != _loc5_)
  428.    {
  429.       var _loc10_ = (_loc4_ > _loc5_) * 2 - 1;
  430.    }
  431.    else
  432.    {
  433.       _loc10_ = (_loc6_ > _loc7_) * 2 - 1;
  434.    }
  435.    this[_loc8_].moveTile(_loc4_,_loc6_,_loc10_,aB2);
  436.    this[_loc9_].moveTile(_loc5_,_loc7_,_loc10_,aB1);
  437.    this.pSwappedTiles[0] = aB1;
  438.    this.pSwappedTiles[1] = aB2;
  439.    if(!aReturn)
  440.    {
  441.       this.pSwishSnd.start();
  442.       this.pTileCheck = 2;
  443.    }
  444.    else
  445.    {
  446.       this.pErrorSnd.start();
  447.       this.selector_mc.setActive(true);
  448.    }
  449.    this.pTileLocs[aB1] = _loc9_;
  450.    this.pTileLocs[aB2] = _loc8_;
  451.    this.pGrid.swapBlocks(aB1,aB2);
  452. };
  453. this.tileClearDone = function()
  454. {
  455.    if(--this.pTileCheck == 0)
  456.    {
  457.       var _loc3_ = this.pGrid.removeBlocks();
  458.       var _loc4_ = this.pTileLocs.slice();
  459.       var _loc9_ = _loc3_[0].length;
  460.       var _loc2_ = 0;
  461.       while(_loc2_ < _loc9_)
  462.       {
  463.          var _loc5_ = _loc3_[0][_loc2_][0];
  464.          var _loc6_ = _loc3_[0][_loc2_][1];
  465.          this[_loc4_[_loc5_]].dropTile(_loc6_,_loc5_);
  466.          this.pTileLocs[_loc5_ + _loc6_ * 8] = _loc4_[_loc5_];
  467.          this.pTileCheck = this.pTileCheck + 1;
  468.          _loc2_ = _loc2_ + 1;
  469.       }
  470.       _loc9_ = _loc3_[1].length;
  471.       _loc2_ = 0;
  472.       while(_loc2_ < _loc9_)
  473.       {
  474.          _loc5_ = _loc3_[1][_loc2_][0];
  475.          var _loc7_ = _loc3_[1][_loc2_][1];
  476.          var _loc8_ = _loc3_[1][_loc2_][2];
  477.          this[_loc4_[_loc5_]].renewTile(_loc7_,_loc8_);
  478.          this.pTileLocs[_loc7_] = _loc4_[_loc5_];
  479.          this.pTileCheck = this.pTileCheck + 1;
  480.          _loc2_ = _loc2_ + 1;
  481.       }
  482.    }
  483. };
  484. this.tileScaleDone = function()
  485. {
  486.    if(--this.pTileCheck == 0)
  487.    {
  488.       this._parent.scores_mc.clearBonus();
  489.       this._parent.scores_mc.updateLevel();
  490.       this.pRange = Math.min(++this.pRange,8);
  491.       this.loadGrid(this.pRange);
  492.       this._parent.timer_mc.increaseSpeed();
  493.       this.pLevelEnd = false;
  494.    }
  495. };
  496. this.tileDropDone = function()
  497. {
  498.    if(--this.pTileCheck == 0)
  499.    {
  500.       var _loc3_ = this.pGrid.checkGrid();
  501.       var _loc4_ = _loc3_.length;
  502.       this.pTileCheck = 0;
  503.       this.pClearedTiles.splice(0);
  504.       if(_loc4_ > 2)
  505.       {
  506.          var _loc2_ = 0;
  507.          while(_loc2_ < _loc4_)
  508.          {
  509.             this[this.pTileLocs[_loc3_[_loc2_]]].removeTile();
  510.             this.pClearedTiles.push(_loc3_[_loc2_]);
  511.             this.pTileCheck = this.pTileCheck + 1;
  512.             _loc2_ = _loc2_ + 1;
  513.          }
  514.       }
  515.       if(_loc4_ == 0)
  516.       {
  517.          if(this.pLevelEnd)
  518.          {
  519.             _loc2_ = 0;
  520.             while(_loc2_ < 64)
  521.             {
  522.                this[this.pTileLocs[_loc2_]].scaleTile();
  523.                this.pTileCheck = this.pTileCheck + 1;
  524.                _loc2_ = _loc2_ + 1;
  525.             }
  526.             this.pLevel = this.pLevel + 1;
  527.             this._parent.soul_mc.clearMap();
  528.          }
  529.          else
  530.          {
  531.             this._parent.scores_mc.clearBonus();
  532.             this.selector_mc.setActive(true);
  533.             this._parent.timer_mc.resumeTimer();
  534.             if(this.pBlockCount == 0)
  535.             {
  536.                this.pBellsSnd.start();
  537.             }
  538.          }
  539.       }
  540.    }
  541. };
  542. this.tileSwapDone = function()
  543. {
  544.    if(--this.pTileCheck == 0)
  545.    {
  546.       this._parent.timer_mc.pauseTimer();
  547.       var _loc4_ = this.pGrid.checkBlocks(this.pSwappedTiles[0]);
  548.       var _loc3_ = this.pGrid.checkBlocks(this.pSwappedTiles[1]);
  549.       var _loc5_ = _loc4_.length;
  550.       var _loc6_ = _loc3_.length;
  551.       if(!(_loc5_ > 2 || _loc6_ > 2))
  552.       {
  553.          this.swapBlocks(this.pSwappedTiles[1],this.pSwappedTiles[0],1);
  554.          this._parent.timer_mc.resumeTimer();
  555.       }
  556.       else
  557.       {
  558.          this.pTileCheck = 0;
  559.          this.pClearedTiles.splice(0);
  560.          if(_loc5_ > 2)
  561.          {
  562.             var _loc2_ = 0;
  563.             while(_loc2_ < _loc5_)
  564.             {
  565.                this[this.pTileLocs[_loc4_[_loc2_]]].removeTile();
  566.                this.pClearedTiles.push(_loc4_[_loc2_]);
  567.                this.pTileCheck = this.pTileCheck + 1;
  568.                _loc2_ = _loc2_ + 1;
  569.             }
  570.          }
  571.          if(_loc6_ > 2)
  572.          {
  573.             _loc2_ = 0;
  574.             while(_loc2_ < _loc6_)
  575.             {
  576.                this[this.pTileLocs[_loc3_[_loc2_]]].removeTile();
  577.                this.pClearedTiles.push(_loc3_[_loc2_]);
  578.                this.pTileCheck = this.pTileCheck + 1;
  579.                _loc2_ = _loc2_ + 1;
  580.             }
  581.          }
  582.       }
  583.    }
  584. };
  585. this.loadGrid = function(tRange)
  586. {
  587.    this.pRange = tRange;
  588.    this._parent.timer_mc.resetTimer();
  589.    this.pGrid.setRange(tRange);
  590.    this.pBlockCount = 0;
  591.    var _loc3_ = undefined;
  592.    var _loc2_ = 0;
  593.    while(_loc2_ < 64)
  594.    {
  595.       _loc3_ = this["t" + _loc2_ + "_mc"];
  596.       _loc3_.pNum = _loc2_;
  597.       _loc3_.pPos.x = -140 + 40 * (_loc2_ % 8);
  598.       _loc3_.pPos.y = -140 + 40 * Math.floor(_loc2_ / 8);
  599.       _loc3_.pColour = this.pGrid.getCellColour(_loc2_);
  600.       this.pTileLocs[_loc2_] = "t" + _loc2_ + "_mc";
  601.       _loc3_.startTile();
  602.       _loc2_ = _loc2_ + 1;
  603.    }
  604.    this.pTileCheck = 64;
  605. };
  606. this.init();
  607. stop();
  608.